from typing import Any, List, Dict
import logging
from pycparser.c_ast import Switch
from starlette.routing import request_response
from typing import List, Tuple, Optional
from Agent.Dispatch.Dao.DispatchRequest import DispatchRequest
from Agent.Dispatch.Dao.DispatchResponse import DispatchResponse
from Agent.FillTable.Service.FillTableService import FillTableService
from Agent.FormAnalyzer.Service.FormAnalyzerService import FormAnalyzerServiceService
from Agent.SecondBarging.Dao.SecondBargainingRequest import SecondBargainingRequest
from Agent.SecondBarging.Dao.SecondBargainingResponse import SecondBargainingResponse
from core.BaseAgent import BaseAgent
from LlmModel.DoubaoModel.DoubaoModel import DoubaoModel, doubao_model
from utils import logger
from utils.round_utils import count_discount_rounds_by_llm, data_guarantee_rounds_by_llm, time_discount_rounds_by_llm, \
    schedule_rounds_by_llm, tone_rounds_by_llm, style_rounds_by_llm
import re
from jinja2 import Template
import os

from utils.chat import getUserInput, getBaseTable, convert_userInput_to_formDict, convert_formDict_to_userInput, \
    splitter, getRecentDiffDiscussConversations
from utils.logger import get_logger, file_log, log_to_file  # 新增导入

fillTableService = FillTableService()
formAnalyzerServiceService = FormAnalyzerServiceService()
logger = get_logger("SecondBargingController")


# baseTable = """1.达人昵称:\n2.达人主页链接:\n3.品牌/产品名称:\n4.产品品类:\n5.推广周期:（12月20日前发布）\n6.投放形式:（报备视频80% 报备图文20%）\n7.报备图文价格:\n8.报备视频价格:\n9.是否可以保价到次月:\n10.折扣要求:（30%）\n11.创作方向:（单品种草）\n12.排竞要求:（前 15 后 15）\n13.寄样方式:（寄拍）\n14.出镜小孩性别/年龄:\n15.达人是否处于孕期:\n16.达人场景体验匹配度:\n17.可保阅读数据:（视频保底1万播放，图文保底7000阅读）\n18.可保互动数据:（点赞+评论≥400）\n19.是否可以免费授权品牌信息流 6 个月？:\n20.是否可以免费授权品牌二剪及全平台传播（包括电商）6 个月？:\n21.是否可以免费分发其他平台？:\n22.是否有特殊合作注意事项？（如广告占比要求、脚本修改次数等）:\n23.是否免费授权电商平台植入 6 个月？:\n24.是否授权搜索引导6 个月？:\n25.是否授权带相关话题6 个月？:\n26.是否授权组件需求6 个月？:\n27.是否授权引流需求6 个月？:"""


class SecondBargingService(BaseAgent):
    def __init__(self):
        self.doubaoModel = DoubaoModel()
        # 添加 logger 初始化
        self.logger = logging.getLogger(__name__)

    async def process(self, input_data: Any) -> Any:
        pass

    @file_log("检查历史对话中user说的有没有补充信息智能体")
    async def handle_fill_agent(self, request: SecondBargainingRequest) -> SecondBargainingResponse:
        """
        处理表单填充逻辑

        :param request:
        :return:
        """
        try:
            # 先看他给的是不是表单，他有可能上来就给表单
            # !!!!基准值是客户给，在第一次的assistants的表单的括号里
            baseTable = getBaseTable(request.conversations)
            user_input = getUserInput(request.conversations)  # 拿到用户本次输入
            logger.info(f"用户最新输入: {user_input}")

            # 问题点
            is_form = formAnalyzerServiceService._is_form_like(user_input)

            if is_form == 1:
                request.form = convert_userInput_to_formDict(user_input.replace("请填写表单\n：", ""))
                # print("--------------request.form-----------------------\n")
                # print(request.form)
                # print("-------------------------------------\n")

                request.is_submit = 1  # 这里就已经跳出a2了
                request.empty_info = formAnalyzerServiceService._check_form_completeness(user_input)  # 初始化empty_info
                #
                # print("-------------------request.empty_info------------------\n")
                # print(request.empty_info)
                # print("-------------------------------------\n")

                logger.info("request.empty_info:{}".format(request.empty_info))
            logger.info("is_form:{}".format(is_form))

            # a2
            if request.is_submit == 0:  # 用户没有提交过表单，
                return await self._handle_negotiable_differences_common(
                    request, baseTable, user_input, is_form, is_c2_mode=False
                )

            # b2
            if request.is_submit == 1 and request.empty_info != []:  # 用户已经提交过表单，并且表单不完整
                empty_prompt = f"""
                请严格分析用户的最新回复中是否补充了缺失的表单字段。
            
## 任务说明：
用户之前缺失的表单字段：{request.empty_info}
用户最新回复内容：{user_input}

## 分析规则：
1. 仔细检查用户回复中是否明确提到了缺失字段的信息
2. 即使回复比较口语化，只要包含相关字段内容就算补充
3. 重点识别关键词匹配：
   - "寄样方式"相关：寄拍、寄送、快递、邮寄、样品等
   - "推广周期"相关：时间、日期、周期、档期等  
   - "折扣要求"相关：折扣、返点、优惠、点数等
   - 其他字段类似判断

## 输出要求：
- 如果用户补充了某个缺失字段，按以下格式返回：
  字段名：补充的具体内容
  例如：寄样方式：寄拍
  
- 如果用户完全没有补充任何缺失字段，返回：
  没有补充

## 当前示例分析：
用户说："不好意思，我的寄样方式为寄拍"
这明确补充了"寄样方式"字段，内容为"寄拍"
因此应该返回：寄样方式：寄拍

请基于以上规则严格分析并输出结果。
                """
                response = await self.doubaoModel.generate_text(empty_prompt)
                log_to_file(f"用户是否补充 {response}")

                # 更新 empty_info 和 form
                if response and response != "没有补充":
                    # 按行分割响应
                    lines = response.strip().split('\n')

                    # 用于记录要删除的字段和要更新的字段
                    fields_to_remove = []
                    fields_to_update = {}

                    for line in lines:
                        line = line.strip()
                        if ':' in line or '：' in line:  # 支持中文和英文冒号
                            # 分割字段名和值
                            separator = ':' if ':' in line else '：'
                            field_parts = line.split(separator, 1)
                            field_name = field_parts[0].strip()
                            field_value = field_parts[1].strip() if len(field_parts) > 1 else ""

                            # 检查字段名是否在 empty_info 中
                            for empty_field in request.empty_info:
                                # 支持带数字前缀的匹配（如 "寄样方式" 匹配 "7.寄样方式"）
                                if empty_field in field_name or field_name in empty_field:
                                    fields_to_remove.append(empty_field)
                                    fields_to_update[field_name] = field_value
                                    break

                    # 更新 empty_info - 删除已补充的字段
                    request.empty_info = [field for field in request.empty_info if field not in fields_to_remove]

                    if request.empty_info == []:
                        agent_response = "太棒了，宝子所有缺失信息已经全部补齐了！"
                    else:
                        agent_response = "好的呢宝子，但是还有一些东西没填完呢" + str(request.empty_info)

                    # 更新 form - 更新已有字段而不是添加新字段
                    for field_name, field_value in fields_to_update.items():
                        # 查找已存在的对应字段
                        existing_field_key = None

                        # 方法1：直接查找对应的数字前缀字段
                        numbered_field_name = self._get_numbered_field_name(field_name)
                        if numbered_field_name in request.form:
                            existing_field_key = numbered_field_name

                        # 方法2：如果没有找到，遍历所有键查找匹配的字段
                        if not existing_field_key:
                            for key in request.form.keys():
                                # 检查键是否包含目标字段名（如 "13.寄样方式" 包含 "寄样方式"）
                                if field_name in key:
                                    existing_field_key = key
                                    break

                        # 方法3：如果还是没找到，使用数字前缀创建新字段（作为备选）
                        if existing_field_key:
                            # 更新已存在的字段
                            request.form[existing_field_key] = field_value
                            logger.info(f"更新字段 {existing_field_key}: {field_value}")
                        else:
                            # 如果确实不存在，使用数字前缀添加（这种情况应该很少）
                            request.form[numbered_field_name] = field_value
                            logger.info(f"添加新字段 {numbered_field_name}: {field_value}")

                    logger.info(f"更新后的 empty_info: {request.empty_info}")
                    logger.info(f"更新后的 form: {request.form}")

                    # is_submit,
                    return SecondBargainingResponse(
                        is_submit=request.is_submit,
                        agent_response=agent_response,
                        cooperation_status="沟通中",
                        empty_info=request.empty_info,
                        form=request.form
                    )

                elif response == "没有补充":
                    return SecondBargainingResponse(
                        is_submit=request.is_submit,
                        agent_response="宝子，如果表单不填完整是无法进行下一步合作的，辛苦您填一下呢，这些是您的缺失内容：" + str(
                            request.empty_info),
                        cooperation_status="沟通中",
                        empty_info=request.empty_info,
                        form=request.form
                    )

            # # 先处理**没写过表单**的情况submit==0  && form =={}
            # if request.is_submit == 0 and request.form == {}:
            #     if is_form:
            #         print(1)
            #         # 用户没写过表单，现在他返回来一个表单的情况(填完要进行完整性判断)
            #         # （userinput中的"请填写表单\n："replace掉）
            #         # request.form = convert_userInput_to_formDict(user_input.replace("请填写表单\n：", ""))
            #     else:#a2
            #         # 判断劝告轮次，如果劝告轮次>=2直接 还是劝他填单，不填不给过
            #
            #
            # """
            # 这里以后Request.form里面一定会有表单
            # 下面做完整性校验
            # """
            #
            # # 下面处理is_submit==0 没过完整性校验 && form!={} 但是填了表，那下面就要去做完整性校验了
            # # 看一下哪里缺的，塞到empty里面
            # # 缺的让他都给补了，补齐没有差异了才能走
            # if request.is_submit == 0 and request.form != {}:
            #     request.empty_info = formAnalyzerServiceService._check_form_completeness(user_input)
            #     logger.info("empty_info:{}".format(request.empty_info))
            #     # print("-------------------------request.empty_info------------------------\n")
            #     # print(request.empty_info)
            #     # print("-------------------------request.empty_info------------------------\n")
            #
            #     if len(request.empty_info) == 0:
            #         # 完整性校验过了，后面开始洽谈
            #         request.is_submit = 1
            #     else:
            #         # 完整性没写全的让他补！！！！！！！！！！！！
            #         return SecondBargainingResponse(
            #             form=request.form,
            #             agent_response="宝子如果表单没有填写完整的话是无法进行一下不合作的哦。\n 以下是您未填的重要信息呢" + str(request.empty_info),
            #             empty_info=request.empty_info
            #         )

            #  c2下面处理is_submit==1的情况，就是之前提交过表单了，验证完整性，差异判断
                """
                2、通过大模型进行差异归因（7可处理状态，9不可处理状态）、
                比较两个表单的差异，返回包含两类差异的复合字典
                返回结构说明：
                - negotiable：dict[int, str]，原7个可议价原因（1-7键，值为空=无差异）
                - non_negotiable：dict[int, str]，新增8个不可议价原因（1-8键，值为空=无差异）
                - has_non_negotiable：bool，是否存在不可议价差异（True=有，需优先处理）
                """

            #c2
            if request.is_submit == 1 and request.empty_info == []:
                # 表单验证
                validation_result = self.handle_form_validation(request, is_form, user_input, baseTable)
                if validation_result is not None:
                    return validation_result

                # 使用通用差异处理逻辑（C2模式）
                return await self._handle_negotiable_differences_common(
                    request, baseTable, user_input, is_form, is_c2_mode=True
                )

                # 默认返回 - 确保所有路径都有返回值

            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的，宝子让我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=is_form
            )

        except Exception as e:
            logger.error(f"Error in fill agent flow: {str(e)}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="错误路径",
                status="",
                reference="666",
                category=request.category,  # 拒绝原因
                subcategory=request.subcategory,  # 小类
                cooperation_status=request.cooperation_status,  # 合作状态大类
                is_first=request.is_first
            )



    @file_log("历史对话中user说的有没有补充信息")
    async def _handle_negotiable_differences_common(self, request, baseTable, user_input, is_form, is_c2_mode=True):
        """
        通用的可议价差异处理逻辑
        is_c2_mode: True=C2模式(有form), False=A2模式(无form)
        """
        try:
            # 获取用于比较的表单内容
            comparison_form = convert_formDict_to_userInput(request.form) if is_c2_mode else ""

            # 差异分析
            negotiable, non_negotiable, has_non_negotiable = await formAnalyzerServiceService.get_forms_differ_unionDict(
                baseTable, comparison_form,user_input ,is_c2_mode, request.is_submit,is_form, request.conversations
            )

            logger.info(f"可议价差异: {negotiable}")
            logger.info(f"不可议价差异: {non_negotiable}")
            logger.info(f"是否存在不可议价差异: {has_non_negotiable}")

            # 不可议价差异处理
            logger.info(f"可议价差异: {negotiable}")
            logger.info(f"不可议价差异: {non_negotiable}")
            logger.info(f"是否存在不可议价差异: {has_non_negotiable}")

            # 不可议价差异处理
            if has_non_negotiable:
                # 初始化
                subcategories = []
                categories = []

                # 处理列表格式的non_negotiable
                if isinstance(non_negotiable, list):
                    for item in non_negotiable:
                        if item:
                            # 先检查中文冒号，再检查英文冒号
                            if "：" in item:
                                parts = item.split("：", 1)
                                subcategories.append(parts[0].strip())
                                categories.append(parts[1].strip())
                            elif ":" in item:
                                parts = item.split(":", 1)
                                subcategories.append(parts[0].strip())
                                categories.append(parts[1].strip())
                            else:
                                # 如果没有冒号，整个作为subcategory
                                subcategories.append(item.strip())
                                categories.append("")

                # 构建字符串
                subcategory_str = "、".join(subcategories)
                category_str = "、".join(categories)

                logger.info(f"subcategories: {subcategories}")
                logger.info(f"categories: {categories}")

                return SecondBargainingResponse(
                    form=request.form,
                    agent_response="好的宝子，已记录",
                    category=category_str,
                    subcategory=subcategory_str,
                    cooperation_status="已拒品",
                    diff_info=negotiable + non_negotiable,
                    is_submit=is_form
                )

            # 可议价差异处理
            # 获取最近对话
            get_recent_conversations_flag = any(
                conv["role"] == "assistant" and splitter in conv["content"]
                for conv in request.conversations
            )

            if get_recent_conversations_flag:
                recent_conversations = getRecentDiffDiscussConversations(request.conversations)
            else:
                if len(request.conversations) >= 6:
                    recent_conversations = request.conversations[-6:]
                elif len(request.conversations) >= 4:
                    recent_conversations = request.conversations[-4:]
                else:
                    recent_conversations = request.conversations

            # 设置差异信息
            if request.diff_info == []:
                request.diff_info = negotiable
                logger.info(f"整个差异列表: {request.diff_info}")
            if len(request.diff_info) > 0:
                diff_line = request.diff_info[0]
                logger.info(f"检测出的获取的差异第一行: {diff_line}")

                #折扣要求预操作
                if is_form != 1:
                    updated_request = self.update_discount_requirement(request, user_input)
                    if updated_request != request:
                        # 如果发生了更新，使用更新后的request
                        request = updated_request
                        diff_line = request.diff_info[0]  # 获取更新后的diff_line
                logger.info(f"折扣要求更新后的差异第一行: {request.diff_info[0]}")
                #推广周期预操作
                request.diff_info, diff_line = self.update_promotion_period(request.diff_info, user_input)
                logger.info(f"推广周期更新后的差异第一行: {diff_line}")

                log_to_file(f"用户提交与基础值对比（无需在意“返点不满足：折扣要求不一致”因为后面对比一致了就为空了，看不了日志所以只能在这里给出日志） {diff_line}")
                log_to_file("该轮稳定性测试结束=============================================================================")
                # 让利 如果用户的值比基础还要大那么就直接在diff_info删掉
                request.diff_info, diff_line = self.check_and_filter_discount_diff(request.diff_info)


                logger.info(f"过滤后的差异第一行: {diff_line}")

                #查看recent_conversations
                logger.info(f"最近对话: {recent_conversations}")
                # 根据差异类型处理
                if "返点不满足" in diff_line:
                    return await self._handle_discount_difference(request, baseTable, user_input, recent_conversations,
                                                                  is_c2_mode)
                elif "排竞时长不满足" in diff_line:
                    return await self._handle_time_difference(request, baseTable, recent_conversations, is_c2_mode,user_input)
                elif "档期不满足" in diff_line:
                    return await self._handle_schedule_difference(request, baseTable, recent_conversations, is_c2_mode,user_input)
                elif "创作风格不符合" in diff_line:
                    return await self._handle_style_difference(request, baseTable, recent_conversations, is_c2_mode,user_input)
                elif "数据不保证" in diff_line:
                    return await self._handle_data_guarantee_difference(request, baseTable, recent_conversations,
                                                                        is_c2_mode,user_input)
                elif "调性不匹配" in diff_line:
                    return await self._handle_tone_difference(request, baseTable, recent_conversations, is_c2_mode,user_input)

            # 没有差异的情况 - 确保这里也有返回
            if is_c2_mode:
                return SecondBargainingResponse(
                    form=request.form,
                    subcategory="已确认",
                    agent_response="宝子，您已经进入了我们的待合作对象清单，过段时间工作人员会联系您，请耐心等待",
                    cooperation_status="确认合作",
                    is_submit=is_form
                )
            else:
                # A2模式没有差异但也没有表单，要求填写表单
                return SecondBargainingResponse(
                    form=request.form,
                    agent_response="我们暂时没有发现差异，请您填写完整表单以便继续推进合作\n：" + baseTable,
                    cooperation_status="沟通中",
                    is_submit=0
                )

        except Exception as e:
            logger.error(f"处理可议价差异时发生错误: {e}")
            # 确保异常情况下也有返回
            return SecondBargainingResponse(
                form=request.form,
                agent_response="系统处理异常，请稍后重试",
                cooperation_status="沟通中",
                is_submit=is_form
            )

    @file_log("轮次智能体")
    async def _handle_discount_difference(self, request, baseTable, user_input, recent_conversations, is_c2_mode):
        """处理折扣差异"""
        try:


            round = await count_discount_rounds_by_llm(recent_conversations, baseTable)
            log_to_file(f"检测出的轮次为: {round}")
            request.diff_info[0] = re.sub(r'基础值：(\d+)(?=[，]|$)', r'基础值：\1%', request.diff_info[0])
            request.diff_info[0] = re.sub(r'用户值：(\d+)(?=[，]|$)', r'用户值：\1%', request.diff_info[0])
            logger.info(f"request.diff_info[0]为: {request.diff_info[0]}")
            chat_state, resp = await self.barging_count(recent_conversations, round, request.diff_info[0])
            logger.info("返回的回复: {}".format(resp))

            return await self._process_difference_result(
                "返点不满足", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_discount_from_base_table
            )
        except Exception as e:
            logger.error(f"处理折扣差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    # 其他差异处理方法也要类似地添加异常处理

    async def _handle_time_difference(self, request, baseTable, recent_conversations, is_c2_mode,user_input):
        """处理时间差异"""
        try:
            round = await time_discount_rounds_by_llm(recent_conversations, baseTable)
            logger.info(f"检测出的轮次为: {round}")

            chat_state, resp = await self.barging_time(recent_conversations, round, request.diff_info[0])
            return await self._process_difference_result(
                "排竞时长不满足", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_ranking_competition_from_base_table
            )
        except Exception as e:
            logger.error(f"处理时间差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    async def _handle_schedule_difference(self, request, baseTable, recent_conversations, is_c2_mode,user_input):
        """处理档期差异"""
        try:
            round = await schedule_rounds_by_llm(recent_conversations, baseTable)
            logger.info(f"检测出的轮次为: {round}")

            chat_state, resp = await self.barging_schedule(recent_conversations, round, request.diff_info[0])
            return await self._process_difference_result(
                "档期不满足", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_promotion_period_from_base_table
            )
        except Exception as e:
            logger.error(f"处理档期差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    async def _handle_style_difference(self, request, baseTable, recent_conversations, is_c2_mode,user_input):
        """处理创作风格差异"""
        try:
            round = await style_rounds_by_llm(recent_conversations, baseTable)
            logger.info(f"检测出的轮次为: {round}")

            chat_state, resp = await self.barging_style(recent_conversations, round, request.diff_info[0])
            return await self._process_difference_result(
                "创作风格不符合", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_creation_direction_from_base_table
            )
        except Exception as e:
            logger.error(f"处理创作风格差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    async def _handle_data_guarantee_difference(self, request, baseTable, recent_conversations, is_c2_mode,user_input):
        """处理数据保证差异"""
        try:
            round = await data_guarantee_rounds_by_llm(recent_conversations, baseTable)
            logger.info(f"检测出的轮次为: {round}")

            chat_state, resp = await self.barging_data_guarantee(recent_conversations, round, request.diff_info[0])
            return await self._process_difference_result(
                "数据不保证", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_data_guarantee_from_base_table
            )
        except Exception as e:
            logger.error(f"处理数据保证差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    async def _handle_tone_difference(self, request, baseTable, recent_conversations, is_c2_mode,user_input):
        """处理调性差异"""
        try:
            round = await tone_rounds_by_llm(recent_conversations, baseTable)
            logger.info(f"检测出的轮次为: {round}")

            chat_state, resp = await self.barging_tone(recent_conversations, round, request.diff_info[0])
            return await self._process_difference_result(
                "调性不匹配", chat_state, resp, request, baseTable, user_input,
                recent_conversations, is_c2_mode, self.update_form_tone_matching_from_base_table
            )
        except Exception as e:
            logger.error(f"处理调性差异时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    async def _process_difference_result(self, diff_type, chat_state, resp, request, baseTable,
                                         user_input, recent_conversations, is_c2_mode, update_form_func):
        """处理差异协商结果的通用逻辑"""
        try:
            if chat_state == 1:
                # 协商成功
                if is_c2_mode:
                    # C2模式：更新表单并继续
                    return self._handle_c2_success(diff_type, resp, request, baseTable, user_input, update_form_func)
                else:
                    # A2模式：要求填写表单
                    return self._handle_a2_success(diff_type, resp, request, baseTable)

            elif chat_state == 0:
                # 协商失败
                return self._handle_negotiation_failure(diff_type, resp, request, is_c2_mode, request.diff_info)

            elif chat_state == 3:
                # 需要继续协商
                return self._handle_continue_negotiation(resp, request, is_c2_mode)
            else:
                # 未知状态，默认处理
                logger.warning(f"未知的chat_state: {chat_state}")
                return SecondBargainingResponse(
                    form=request.form,
                    agent_response="好的宝子，等待我来处理一下哦",
                    cooperation_status="沟通中",
                    is_submit=1
                )
        except Exception as e:
            logger.error(f"处理差异结果时发生错误: {e}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="好的宝子，等待我来处理一下哦",
                cooperation_status="沟通中",
                is_submit=1
            )

    def _handle_c2_success(self, diff_type, resp, request, baseTable, user_input, update_form_func):
        """C2模式协商成功处理"""
        if diff_type in str(request.diff_info[0]):
            del request.diff_info[0]

        update_form = update_form_func(request.form, baseTable, user_input)

        if len(request.diff_info) > 0:
            chat_supply = f"好的呢宝子，但是还有一些需要商榷的问题呢:\n1. {request.diff_info[0]}\n"
            return SecondBargainingResponse(
                form=update_form,
                agent_response=resp + chat_supply + splitter,
                diff_info=request.diff_info,
                is_submit=1,
                cooperation_status="沟通中"
            )
        else:
            return SecondBargainingResponse(
                form=update_form,
                subcategory="已确认",
                diff_info=request.diff_info,
                is_submit=1,
                agent_response="宝子，您已经进入了我们的待合作对象清单，过段时间工作人员会联系您，请耐心等待",
                cooperation_status="确认合作"
            )

    def _handle_a2_success(self, diff_type, resp, request, baseTable):
        """A2模式协商成功处理 - 要求填写表单"""
        # 删除已解决的差异
        if diff_type in str(request.diff_info[0]):
            del request.diff_info[0]

        # 要求用户填写表单
        form_prompt = "\n\n收到，宝子。辛苦填一下表单哈~：\n" + baseTable
        return SecondBargainingResponse(
            form=request.form,
            agent_response=resp + form_prompt,
            subcategory = "博主权益落实中",
            diff_info=request.diff_info,
            is_submit=0,  # 标记需要填写表单
            cooperation_status="沟通中"
        )

    def _handle_negotiation_failure(self, diff_type, resp, request, is_c2_mode,diff_reason):
        """协商失败处理"""
        # 在生成 category 的地方
        category_in = f"{diff_type}无法达到客户指定要求,{diff_reason}"

        # 进行替换
        category_fi = category_in.replace("基础值", "客户值").replace("用户值", "达人值")
        return SecondBargainingResponse(
            form=request.form,
            agent_response=resp,
            cooperation_status="已拒品",
            diff_info=request.diff_info,
            is_submit = 1 if is_c2_mode == True else 0,
            category=category_fi,
            subcategory=diff_type
        )

    def _handle_continue_negotiation(self, resp, request, is_c2_mode):
        """继续协商处理"""
        return SecondBargainingResponse(
            form=request.form,
            agent_response=resp,
            diff_info=request.diff_info,
            cooperation_status="沟通中",
            subcategory="博主权益落实中",
            is_submit = 1 if is_c2_mode == True else 0
        )



    async def _handle_global_qa(self, request):
        pass

    async def get_admonition_count(self, conversations: List[Dict[str, str]]) -> int:
        """
        使用大模型统计劝用户填表的次数

        :param conversations: 对话历史记录
        :return: 劝用户填表的次数
        """
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""请分析以下对话内容，统计系统（assistant）劝用户填写表单的次数。

    判断标准：
    1. 当assistant提醒用户需要补充表单信息
    2. 当assistant指出表单不完整
    3. 当assistant要求用户填写或完善表单

    对话内容：
    {conversation_text}

    请只返回一个数字，表示劝用户填表的次数。如果没有找到相关内容，返回0。"""

            # 调用大模型
            response = await self.doubaoModel.generate_text(prompt)

            # 尝试解析返回的数字
            try:
                count = int(response.strip())
                return count
            except ValueError:
                # logger.warning(f"大模型返回的劝填表次数格式不正确: {response}")
                return 0

        except Exception as e:
            # logger.error(f"统计劝填表次数失败: {str(e)}")
            return 0

    @file_log("历史对话中user说的有没有补充信息")
    async def barging_tone(self, conversations: List[Dict[str, str]], round, diff_line):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 提取调性信息
            tonality_match = re.search(r'调性要求为：\s*(.*)', diff_line)
            tonality = tonality_match.group(1) if tonality_match else "未知"

            # 提取我们的调性信息
            our_tonality_match = re.search(r'我们的调性要求为：\s*(.*)', diff_line)
            our_tonality = our_tonality_match.group(1) if our_tonality_match else tonality

            log_to_file("用户值为：{}".format(tonality))
            # 提取我们的折扣要求

            log_to_file("基础值为：{}".format(our_tonality))
            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
            您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

            #### 状态判断逻辑（第一轮）：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
            - 如果博主回复内容表示同意合作（如包含"好"、"同意"、"可以"、"保证"等正面关键词并且没有提到账号与品牌调性不匹配或粉丝人群与品牌不匹配并且博主说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}符合），输出数字1。
            - 如果博主回复内容明确表示拒绝合作（如user说出"不合作"、"不行"、"调性不匹配"、"粉丝人群不匹配"等，或者说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}不符合），输出数字3。
            请只输出状态数字（1或3），不要输出任何其他内容。

            对话历史：
            {conversation_text}
            """

            elif round == 1:
                # 第二轮提示词
                prompt = f"""
            您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

            #### 状态判断逻辑（第二轮）：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
            - 如果博主回复内容表示同意合作（如包含"好"、"同意"、"可以"、"保证"等正面关键词并且没有提到账号与品牌调性不匹配或粉丝人群与品牌不匹配并且博主说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}符合），输出数字1。
            - 如果博主回复内容表示拒绝调性要求或拒绝合作（如user说出"不"、"不行"、"调性不匹配"、"粉丝人群不匹配"等，或者说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}不符合），输出数字3。
            请只输出状态数字（1或3），不要输出任何其他内容。

            对话历史：
            {conversation_text}
            """

            else:
                # 第三轮提示词
                prompt = f"""
            #### 状态判断逻辑（第三轮）：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
            - 如果博主回复内容表示同意合作（如包含"好"、"同意"、"可以"、"保证"等正面关键词并且没有提到账号与品牌调性不匹配或粉丝人群与品牌不匹配并且博主说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}符合），输出数字1。
            - 如果博主回复内容表示拒绝调性要求或拒绝合作（如user说出"不"、"不行"、"调性不匹配"、"粉丝人群不匹配"等，或者说出的调性相关的对话与{diff_line}中我们的调性要求{our_tonality}不符合），输出数字0。
            请只输出状态数字（1或0），不要输出任何其他内容。

            对话历史：
            {conversation_text}
            """

            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")

            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            # 确保状态在有效范围内
            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [1, 0]:
                status = 0  # 第三轮默认拒绝

            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""
            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，粉丝画像还是匹配的，麻烦再考虑一下哈"
            elif round == 1:
                # 第二轮回复话术
                reply = f"宝子再考虑考虑吗，"
            else:
                # 第三轮回复话术
                reply = "好的宝子，待项目确认后再与您继续沟通哈~"
            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"

    #
    # async def barging_demand(self, conversations: List[Dict[str, str]], round ,diff_line):
    #     try:
    #         # 按时间顺序拼接对话内容
    #         conversation_text = "\n".join([
    #             f"{msg.get('role', '')}: {msg.get('content', '')}"
    #             for msg in conversations
    #         ])
    #
    #         # 构建判断提示词
    #         prompt = f"""
    #
    #         当博主回复中包含以下需求不匹配情况时：
    #         - "只接图文，不接视频"/"只接视频，不接图文"
    #         - "没接过这类的品，暂不考虑"
    #         - "没做过线下探店，我只做线上种草内容"
    #         - "这个产品不适合做视频"
    #         或类似大意的回复
    #
    #         请基于用户填写的表单数据，生成一个友好且灵活的回复消息。回复要求：
    #         1. 以“宝子，你好！”开头，语气亲切自然
    #         2. 首先表达理解和尊重博主的创作习惯
    #         3. 针对具体问题提供解决方案：
    #
    #         • 如果博主偏好某种内容形式（图文/视频）：
    #            “完全理解宝子对”投放形式”的偏好！其实我们”品牌/产品名称”的”产品品类”在”创作方向”上，”图文/视频”都能很好展现呢～如果你目前只想做”图文/视频”，我们可以按照”报备图文价格/报备视频价格”来调整合作方案”
    #
    #         • 如果博主表示没接过这类产品：
    #            “谢谢宝子的坦诚！很多博主第一次接触”产品品类”都有类似想法，但最后效果都很惊喜呢～我们可以根据你的”创作方向”来定制内容，”寄样方式”也很方便，还能”免费展示套数及加价””
    #
    #         • 如果博主只做线上不做线下：
    #            “明白宝子专注线上内容！我们的合作完全可以线上完成，通过”寄样方式”寄送产品，你按照”创作方向”创作”投放形式”就好～还有”可保阅读数据”阅读数据保障呢”
    #
    #         • 如果博主认为产品不适合视频：
    #            “理解宝子的顾虑！其实”产品品类”通过视频能更好展示”创作方向”呢，我们可以提供详细的视频参考，而且”报备视频价格”也很优惠，还包含”免费授权品牌信息流6个月”等权益”
    #
    #         4. 突出合作优势：
    #            - 提及价格优势：”报备图文价格”/”报备视频价格”
    #            - 数据保障：”可保阅读数据”/”可保互动数据”
    #            - 免费权益：”免费展示套数及加价”、各项授权权益
    #            - 灵活调整：可根据”折扣要求”、”创作方向”等灵活调整
    #
    #         5. 结尾邀请进一步沟通：
    #            “宝子要不要我们再详细聊聊？看看怎么调整最能满足你的需求～期待能找到双方都满意的合作方式！😊”
    #
    #         注意事项：
    #         - 根据博主具体回复重点选择最相关的3-4个表单字段引用
    #         - 保持回复长度在180-250字
    #         - 回复中可适当使用表情符号增强亲和力，但不要过度。
    #         - 如果某些字段为空，自动跳过相关部分
    #         - 回复不要表现出你是AI，而是以合作者身份回复，语气亲切、自然。
    #         - 确保回复针对博主的具体顾虑进行解答。
    #
    #         #### 状态判断逻辑：
    #         - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）。
    #         - 计算博主回复的消息数量：
    #         - 如果这是第一个博主回复（即对话历史中只有一个博主消息），且回复内容表示同意合作（如包含“好”、“同意”、“可以”、“合作”等正面关键词），输出数字1。
    #         - 如果这是第一个博主回复，且回复内容表示拒绝合作（如包含“不”、“拒绝”、“不匹配”、“不适合”等负面关键词），并且对话历史中只有两个消息（品牌方初始消息和博主回复），输出数字3。
    #         - 如果这是第二个博主回复（即对话历史中有两个博主消息），且回复内容表示同意合作，输出数字1。
    #         - 如果这是第二个博主回复，且回复内容表示拒绝合作，输出数字0。
    #         - 如果对话轮次超过第二轮，默认输出数字0（视为失败），但重点处理第一轮和第二轮。
    #         注意先回复判断的状态数字，在正常回复
    # {conversation_text}
    #
    # """
    #
    #         # 调用大模型
    #         response = await doubao_model.generate_text(prompt)
    #         # 分离状态数字和回复内容
    #         status1 = response.strip()[0]  # 获取第一个字符作为状态
    #         # 把status转为int型
    #         status = int(status1)
    #         reply = response.strip()[1:]  # 获取剩余部分作为回复内容
    #         return status, reply
    #
    #     except Exception as e:
    #         return -1, f"运行出错: {str(e)}"
    @file_log("历史对话中user说的有没有补充信息")
    async def barging_data_guarantee(self, conversations: List[Dict[str, str]], round, diff_line):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 提取基础值数据（播放量和互动量）
            base_match = re.search(r'基础值：播放保(\d+)，点赞\+评论≥(\d+)', diff_line)
            base_play_count = base_match.group(1) if base_match else "未知"
            base_interaction = base_match.group(2) if base_match else "未知"

            # 提取用户值数据（播放量和互动量）
            user_match = re.search(r'用户值：播放保(\d+)，点赞\+评论≥(\d+)', diff_line)
            user_play_count = user_match.group(1) if user_match else "未知"
            user_interaction = user_match.group(2) if user_match else "未知"

            log_to_file("用户值为：{}".format(base_play_count+base_interaction))
            # 提取我们的折扣要求

            log_to_file("基础值为：{}".format(user_play_count+user_interaction))
            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
        - 如果回复内容表示同意合作（如包含"好"、"同意"、"可以"、"合作"等正面关键词）并且{user_play_count}大于{base_play_count}并且{user_interaction}大于{base_interaction}的话，输出数字1。
        - 如果回复内容表示拒绝合作（如user说出"不"、"拒绝"、"不同意"等反面的关键词）并且{user_play_count}小于{base_play_count}或{user_interaction}小于{base_interaction}的话，输出数字3。

        请只输出状态数字（1或3），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """
            elif round == 1:
                # 第二轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
        - 如果回复内容表示同意合作（如包含"好"、"同意"、"可以"、"合作"等正面关键词）并且{user_play_count}大于{base_play_count}并且{user_interaction}大于{base_interaction}的话，输出数字1。
        - 如果回复内容表示拒绝合作（如user说出"不"、"拒绝"、"不同意"等反面的关键词）并且{user_play_count}小于{base_play_count}或{user_interaction}小于{base_interaction}的话，输出数字3。

        请只输出状态数字（1或3），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """
            else:
                # 第三轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
        - 如果回复内容表示同意合作（如包含"好"、"同意"、"可以"、"合作"等正面关键词）并且{user_play_count}大于{base_play_count}并且{user_interaction}大于{base_interaction}的话，输出数字1。
        - 如果回复内容表示拒绝合作（如user说出"不"、"拒绝"、"不同意"等反面的关键词）并且{user_play_count}小于{base_play_count}或{user_interaction}小于{base_interaction}的话，输出数字3。


        请只输出状态数字（1或0），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """
            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")
            logger.info(f"基础值：播放保{base_play_count}，点赞+评论≥{base_interaction}")
            logger.info(f"用户值：播放保{user_play_count}，点赞+评论≥{user_interaction}")


            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            # 确保状态在有效范围内
            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [0, 1]:
                status = 0  # 第三轮默认拒绝
            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""
            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，你的商单数据一般能保多少呢"
            elif round == 1:
                # 第二轮回复话术
                reply = f"好的宝子，已记录"
            else:
                # 第三轮回复话术
                # logger.info(f"用户档期: {user_date}, 我们档期: {our_date}")
                reply = f"好的宝子，待项目确认后再与您继续沟通哈~"

            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"

    @file_log("历史对话中user说的有没有补充信息")
    async def barging_style(self, conversations: List[Dict[str, str]], round, diff_line):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 提取创作方向信息
            direction_match = re.search(r'用户值：([^，,]+)', diff_line)
            direction = direction_match.group(1) if direction_match else "未知"

            # 提取我们的创作方向要求
            our_direction_match = re.search(r'基础值：([^，,]+)', diff_line)
            our_direction = our_direction_match.group(1) if our_direction_match else direction

            log_to_file("用户值为：{}".format(direction))
            # 提取我们的折扣要求

            log_to_file("基础值为：{}".format(our_direction))
            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        请严格按照以下逻辑判断，只输出状态数字（1或3），不要输出任何其他内容：

        1. 首先判断博主是否明确同意合作：
           - 包含"好"、"同意"、"可以"、"合作"等正面关键词视为同意

        2. 再判断创作方向是否相关：
           - 相关：两个方向属于同一领域、互补领域或有明确关联（如"美妆测评"与"护肤品测评"）
           - 不相关：两个方向属于完全不同的领域（如"测评"与"户外探险"）

        3. 只有同时满足以下条件，才输出数字1：
           - 博主明确同意合作
           - 用户创作方向"{direction}"与我们的"{our_direction}"相关

        4. 只有同时满足以下条件，才输出数字3：
           - 博主明确拒绝合作（包含"不"、"不行"、"拒绝"等负面关键词）
           - 用户创作方向"{direction}"与我们的"{our_direction}"不相关

        5. 其他任何情况（包括判断不清的情况），均输出数字3
        请只输出状态数字（1或3），不要输出任何其他内容
        对话历史：
        {conversation_text}
        """
            elif round == 1:
                # 第二轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        请严格按照以下逻辑判断，只输出状态数字（1或3），不要输出任何其他内容：

        1. 首先判断博主是否明确同意合作：
           - 包含"好"、"同意"、"可以"、"合作"等正面关键词视为同意

        2. 再判断创作方向是否相关：
           - 相关：两个方向属于同一领域、互补领域或有明确关联（如"美妆测评"与"护肤品测评"）
           - 不相关：两个方向属于完全不同的领域（如"测评"与"户外探险"）

        3. 只有同时满足以下条件，才输出数字1：
           - 博主明确同意合作
           - 用户创作方向"{direction}"与我们的"{our_direction}"相关

        4. 只有同时满足以下条件，才输出数字3：
           - 博主明确拒绝合作（包含"不"、"不行"、"拒绝"等负面关键词）
           - 用户创作方向"{direction}"与我们的"{our_direction}"不相关

        5. 其他任何情况（包括判断不清的情况），均输出数字3
        请只输出状态数字（1或3），不要输出任何其他内容
        对话历史：
        {conversation_text}
        """
            else:
                # 第三轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        请严格按照以下逻辑判断，只输出状态数字（0或1），不要输出任何其他内容：

        1. 首先判断博主是否明确同意合作：
           - 包含"好"、"同意"、"可以"、"合作"等正面关键词视为同意

        2. 再判断创作方向是否相关：
           - 相关：两个方向属于同一领域、互补领域或有明确关联（如"美妆测评"与"护肤品测评"）
           - 不相关：两个方向属于完全不同的领域（如"测评"与"户外探险"）

        3. 只有同时满足以下条件，才输出数字1：
           - 博主明确同意合作
           - 用户创作方向"{direction}"与我们的"{our_direction}"相关

        4. 只有同时满足以下条件，才输出数字0：
           - 博主明确拒绝合作（包含"不"、"不行"、"拒绝"等负面关键词）
           - 用户创作方向"{direction}"与我们的"{our_direction}"不相关

        5. 其他任何情况（包括判断不清的情况），均输出数字0
        对话历史：
        {conversation_text}
        """
            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")

            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            # 确保状态在有效范围内
            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [0, 1]:
                status = 0  # 第三轮默认拒绝
            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""
            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，你可以根据实际情况填写进表单哈"
            elif round == 1:
                # 第二轮回复话术
                reply = f"好的宝子，已记录"
            else:
                # 第三轮回复话术
                reply = f"好的宝子，待项目确认后再与您继续沟通哈~"

            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"

    @file_log("历史对话中user说的有没有补充信息")
    async def barging_time(self, conversations: List[Dict[str, str]], round, diff_line):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            our_rank_match = re.search(r'排竞时长不满足[：:].*?基础值：前\s*(\d+)\s*后\s*(\d+)|基础值：前后\s*(\d+)',
                                       diff_line)

            if our_rank_match:
                if our_rank_match.group(1) and our_rank_match.group(2):
                    # 格式1：前X后Y
                    front_value = our_rank_match.group(1)
                    back_value = our_rank_match.group(2)
                    our_rank = f"前{front_value}后{back_value}"

                else:
                    # 格式2：前后Z
                    common_value = our_rank_match.group(3)
                    our_rank = f"前后{common_value}"
            else:
                our_rank = "未知"

            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
        您是一个与内容创作者沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑（第一轮）：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）
        1. 在博主回复内容表示同意合作（如包含“好”、“同意”、“可以”、“保证”等正面关键词
        2. 同时检查排竞时长与{diff_line}中我们的排竞时长{our_rank}是否符合（你需要特别注意(若博主回复的为前16后15，我们的排竞时长{our_rank}为前15后15，由于在接单场景中，排竞前16后15包含了{our_rank}，所以博主回复的排竞时长与{our_rank}此时也符合)
        ，因此你需要根据博主回复以及们的排竞时长{our_rank}判断是否存在上述包含关系。）
        3， 只有当以上两个条件同时满足时，才输出数字1。



        4. 如果博主回复内容表示拒绝排竞要求或拒绝合作（如user说出“不”、“不行”等负面关键词）
        5. 并且说出的排竞时长与{diff_line}中我们的排竞时长{our_rank}不符合
        6. 只有当4和5同时满足时，才输出数字3


        请只输出状态数字（1或3），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """

            elif round == 1:
                # 第二轮提示词
                prompt = f"""

        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑（第二轮）：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）
        1. 在博主回复内容表示同意合作（如包含“好”、“同意”、“可以”、“保证”等正面关键词
        2. 同时检查排竞时长与{diff_line}中我们的排竞时长{our_rank}是否符合（你需要特别注意(若博主回复的为前16后15，我们的排竞时长{our_rank}为前15后15，由于在接单场景中，排竞前16后15包含了{our_rank}，所以博主回复的排竞时长与{our_rank}此时也符合)
        ，因此你需要根据博主回复以及们的排竞时长{our_rank}判断是否存在上述包含关系。）
        3， 只有当以上两个条件同时满足时，才输出数字1。



        4. 如果博主回复内容表示拒绝排竞要求或拒绝合作（如user说出“不”、“不行”等负面关键词）
        5. 并且说出的排竞时长与{diff_line}中我们的排竞时长{our_rank}不符合
        6. 只有当4和5同时满足时，才输出数字3


6232123
        请只输出状态数字（1或3），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """

            else:
                # 第三轮提示词
                prompt = f"""
        您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

        #### 状态判断逻辑（第三轮）：
        - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）
        1. 在博主回复内容表示同意合作（如包含“好”、“同意”、“可以”、“保证”等正面关键词
        2. 同时检查排竞时长与{diff_line}中我们的排竞时长{our_rank}是否符合（你需要特别注意(若博主回复的为前16后15，我们的排竞时长{our_rank}为前15后15，由于在接单场景中，排竞前16后15包含了{our_rank}，所以博主回复的排竞时长与{our_rank}此时也符合)
        ，因此你需要根据博主回复以及们的排竞时长{our_rank}判断是否存在上述包含关系。）
        3， 只有当以上两个条件同时满足时，才输出数字1。



        4. 如果博主回复内容表示拒绝排竞要求或拒绝合作（如user说出“不”、“不行”等负面关键词）
        5. 并且说出的排竞时长与{diff_line}中我们的排竞时长{our_rank}不符合
        6. 只有当4和5同时满足时，才输出数字0


        请只输出状态数字（1或0），不要输出任何其他内容。

        对话历史：
        {conversation_text}
        """

            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")

            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            # 确保状态在有效范围内
            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [1, 0]:
                status = 0  # 第三轮默认拒绝

            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""
            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，排竞时间你可以根据实际情况填写哈~"
            elif round == 1:
                # 第二轮回复话术
                reply = f"排竞时间根据我们的方法来，可能更容易定号哦！再考虑一下吧"
            else:
                # 第三轮回复话术
                reply = "好的宝子，待项目确认后再与您继续沟通哈~"

            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"

    @file_log("历史对话中user说的有没有补充信息")
    async def barging_count(self, conversations: List[Dict[str, str]], round: int, diff_line: str):
        """
        使用大模型分析对话状态

        :param conversations: 对话历史记录
        :param round: 对话轮次
        :param diff_line: 差异描述
        :return: 状态码和回复内容
        """
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 提取折扣信息
            discount, our_discount = self.extract_discounts(diff_line)
            log_to_file("用户值为：{}".format(discount))
            # 提取我们的折扣要求

            log_to_file("基础值为：{}".format(our_discount))
            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
                #### 状态判断逻辑（第一轮）：
                - 折扣{discount}%大于等于我们的折扣{our_discount}%），输出数字1。
                - 折扣{discount}小于我们的折扣{our_discount}%），输出数字3。

                请只输出状态数字（1或3），不要输出任何其他内容。
                """
            elif round == 1:
                # 第二轮提示词
                prompt = f"""
                您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

                #### 状态判断逻辑（第二轮）：
                - 基于对话历史（假设消息序列按顺序提供，每条消息的发送者是"品牌方"或"博主"）
                - 如果回复内容表示同意合作（如包含"好"、"同意"、"可以"、"合作"等正面关键词并且说出的折扣{diff_line}大于等于{our_discount}），输出数字1。
                - 如果回复内容表示拒绝合作（如user说出"不"并且说出的折扣{diff_line}小于{our_discount}），输出数字3。

                请只输出状态数字（1或3），不要输出任何其他内容。

                对话历史：
                {conversation_text}


                """
            else:
                # 第三轮提示词（继承第二轮的状态判断逻辑）
                prompt = f"""
                您是一个与小红书博主沟通合作的 AI 助手，负责分析博主对合作提议的回复状态。

                #### 状态判断逻辑（第三轮）：
                - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者"品牌方"或"博主"和内容）
                - 如果回复内容表示同意合作（如包含"好"、"同意"、"可以"、"合作"等正面关键词并且说出的说出的折扣{diff_line}大于等于{our_discount}），输出数字1。
                - 如果回复内容表示拒绝合作（如user说出"不"并且说出的折扣折扣{diff_line}小于{our_discount}），输出数字0。

                请只输出状态数字（1或0），不要输出任何其他内容。

                对话历史：
                {conversation_text}
                """

            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")

            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [1, 0]:
                status = 0  # 第三轮默认拒绝

            discount = f"{discount.rstrip('%')}%" if discount != "未知" else discount
            our_discount = f"{our_discount.rstrip('%')}%" if our_discount != "未知" else our_discount
            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""

            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，您的返点为{discount}，但本次项目的返点要求是{our_discount}，这样合作机率大很多，可以吗？"
            elif round == 1:
                # 第二轮回复话术
                reply = f"宝子，品牌挺有诚意的，当前您的返点为{discount}，如果内容做得好还有投流的机会哦，返点能给到{our_discount}吗"
            else:
                # 第三轮回复话术
                reply = "好的宝子，待项目确认后再与您继续沟通哈~"

            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"

    @file_log("历史对话中user说的有没有补充信息")
    async def barging_schedule(self, conversations: List[Dict[str, str]], round: int, diff_line: str):
        """
        使用大模型分析对话状态

        :param conversations: 对话历史记录
        :param round: 对话轮次
        :param diff_line: 差异描述
        :return: 状态码和回复内容
        """
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 提取档期信息（用户值）

            user_date, our_date = self.extract_dates(diff_line)
            logger.info(f"重要的基础时间值: {our_date}")

            log_to_file("用户值为：{}".format(user_date))
            # 提取我们的折扣要求

            log_to_file("基础值为：{}".format(our_date))

            # 根据轮次构建不同的提示词
            if round == 0:
                # 第一轮提示词
                prompt = f"""
    您是一个与小红书博主沟通合作的AI助手，负责分析博主对合作提议的回复状态。

    请严格按照以下逻辑判断并只输出状态数字（1或3），不要输出任何其他内容：

    1. 首先检查博主的回复中是否有明确同意合作的表达（如包含"好"、"同意"、"可以"、"合作"等正面关键词）
    2. 同时检查：{user_date}是否早于或等于{our_date}
    3. 以上两个条件满足其一就是或关系满足时，才输出数字1

    4. 如果博主的回复中有明确拒绝合作的表达（如包含"不"、"不行"、"拒绝"等负面关键词）
    5. 并且{user_date}晚于{our_date}
    6. 只有当以上两个条件同时满足时，才输出数字3

    7. 如果以上条件都不满足，请输出数字3

    对话历史：
    {conversation_text}
    """
            elif round == 1:
                # 第二轮提示词
                prompt = f"""
    您是一个与小红书博主沟通合作的AI助手，负责分析博主对合作提议的回复状态。

    请严格按照以下逻辑判断并只输出状态数字（1或3），不要输出任何其他内容：

    1. 首先检查博主的回复中是否有明确同意合作的表达（如包含"好"、"同意"、"可以"、"合作"等正面关键词）
    2. 同时检查：{user_date}是否早于或等于{our_date}
    3. 只有当以上两个条件同时满足时，才输出数字1

    4. 如果博主的回复中有明确拒绝合作的表达（如包含"不"、"不行"、"拒绝"等负面关键词）
    5. 并且{user_date}晚于{our_date}
    6. 只有当以上两个条件同时满足时，才输出数字3

    7. 如果以上条件都不满足，请输出数字3
    对话历史：
    {conversation_text}
    """
            else:
                # 第三轮提示词
                prompt = f"""
    您是一个与小红书博主沟通合作的AI助手，负责分析博主对合作提议的回复状态。

    请严格按照以下逻辑判断并只输出状态数字（1或0），不要输出任何其他内容：

    1. 首先检查博主的回复中是否有明确同意合作的表达（如包含"好"、"同意"、"可以"、"合作"等正面关键词）
    2. 同时检查：{user_date}是否早于或等于{our_date}
    3. 只有当以上两个条件同时满足时，才输出数字1

    4. 如果博主的回复中有明确拒绝合作的表达（如包含"不"、"不行"、"拒绝"等负面关键词）
    5. 并且{user_date}晚于{our_date}
    6. 只有当以上两个条件同时满足时，才输出数字0

    7. 如果以上条件都不满足，请输出数字0

    对话历史：
    {conversation_text}
    """
            # 调用大模型获取状态
            response = await self.doubaoModel.generate_text(prompt)
            logger.info(f"大模型状态判断响应: {response}")

            # 提取状态数字
            status = -1
            numbers = re.findall(r'\d+', response.strip())
            if numbers:
                status = int(numbers[0])

            # 确保状态在有效范围内
            if round == 0 and status not in [1, 3]:
                status = 3  # 第一轮默认拒绝
            elif round == 1 and status not in [1, 3]:
                status = 3  # 第二轮默认拒绝
            elif round == 2 and status not in [0, 1]:
                status = 0  # 第三轮默认拒绝
            # 根据状态和轮次生成固定回复话术
            if status == 1:
                # 同意合作，不需要进一步回复
                reply = ""
            elif round == 0:
                # 第一轮回复话术
                reply = f"宝子，您最快的档期最快什么时候，辛苦填写一下哈~，如果能和我们的日期符合的话那么就可以快速定号哦"
            elif round == 1:
                # 第二轮回复话术
                reply = f"宝子再争取一下嘛，我们要求的日期是{our_date},可以在这个日期之前吗？"
            else:
                # 第三轮回复话术
                logger.info(f"用户档期: {user_date}, 我们档期: {our_date}")
                reply = f"好的宝子，待项目确认后再与您继续沟通哈~"

            log_to_file("该轮稳定性测试结束=============================================================================")
            return status, reply

        except Exception as e:
            logger.error(f"分析对话出错: {str(e)}")
            return -1, f"运行出错: {str(e)}"


    # 添加一个辅助方法来获取带数字前缀的字段名
    def _get_numbered_field_name(self, field_name: str) -> str:
        """根据字段名返回带数字前缀的完整字段名"""
        field_mapping = {
            "达人昵称": "1.达人昵称",
            "达人主页链接": "2.达人主页链接",
            "品牌/产品名称": "3.品牌/产品名称",
            "产品品类": "4.产品品类",
            "推广周期": "5.推广周期",
            "投放形式": "6.投放形式",
            "报备图文价格": "7.报备图文价格",
            "报备视频价格": "8.报备视频价格",
            "笔记报价": "9.笔记报价",
            "可保阅读数据": "10.可保阅读数据",
            "可保互动数据": "11.可保互动数据",
            "折扣要求": "12.折扣要求",
            "排竞要求": "13.排竞要求",
            "寄样方式": "14.寄样方式",
            "创作方向": "15.创作方向"
        }
        return field_mapping.get(field_name, field_name)

    def update_form_discount_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取折扣值并更新request.form的10.折扣要求字段，删除多余的折扣要求字段
        """
        try:
            logger.info("=== 开始执行 update_form_discount_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取折扣值 - 修改正则表达式匹配实际格式
            discount_match = re.search(r'10\.折扣要求:\s*（\s*不低于\s*(\d+)\s*%?\s*）', base_table)

            # 如果上面的模式没匹配到，尝试其他可能的格式
            if not discount_match:
                discount_match = re.search(r'10\.折扣要求:\s*（\s*(\d+)\s*%?\s*）', base_table)

            # 提取用户给到的值
            user_discount_value = None
            if discount_match:
                base_discount = int(discount_match.group(1))
                logger.info(f"✅ 成功提取基础折扣要求: {base_discount}%")

                # 从用户输入中提取大于基础折扣的数字（更严格的匹配）
                # 匹配模式：数字+%，且数字在合理范围内（10-100）
                user_discount_matches = re.findall(r'(\d{2,3})%', user_input)
                for match in user_discount_matches:
                    user_discount = int(match)
                    if 10 <= user_discount <= 100 and user_discount > base_discount:
                        user_discount_value = user_discount
                        logger.info(f"✅ 提取到有效用户折扣值: {user_discount_value}% (大于基础折扣{base_discount}%)")
                        break  # 取第一个大于基础折扣的值

                # 决定最终使用的折扣值
                if user_discount_value is not None:
                    final_discount_value = str(user_discount_value) + "%"
                    logger.info(f"✅ 使用用户提供的折扣值: {final_discount_value}")
                else:
                    final_discount_value = discount_match.group(1) + "%"
                    logger.info(f"✅ 使用基础折扣值: {final_discount_value}")

                # 更新 10.折扣要求 字段
                old_value = updated_form.get('10.折扣要求', '未设置')
                updated_form['10.折扣要求'] = final_discount_value
                logger.info(f"✅ 更新 '10.折扣要求': {old_value} -> {final_discount_value}")

                # 删除多余的 '折扣要求' 字段（如果存在）
                if '折扣要求' in updated_form:
                    del updated_form['折扣要求']
                    logger.info("✅ 删除多余的 '折扣要求' 字段")

            else:
                logger.warning("❌ 未能在baseTable中找到折扣要求")
                # 调试信息：显示baseTable内容
                logger.info(f"baseTable内容: {base_table}")

            logger.info(f"最终form的10.折扣要求: {updated_form.get('10.折扣要求', '未找到')}")
            logger.info("=== 结束 update_form_discount_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新折扣要求时出错: {str(e)}", exc_info=True)
            return request_form

    def update_form_ranking_competition_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取排竞要求值并更新request.form的12.排竞要求字段，删除多余的排竞要求字段
        """
        try:
            logger.info("=== 开始执行 update_form_ranking_competition_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取排竞要求值 - 匹配格式如：前7后7、前10后10等
            ranking_match = re.search(r'12\.排竞要求:\s*（\s*(前后\d+天?)\s*）', base_table)

            if ranking_match:
                ranking_value = ranking_match.group(1)  # 直接获取"前7后7"这样的格式
                logger.info(f"✅ 成功提取排竞要求: {ranking_value}")

                # 更新 12.排竞要求 字段
                old_value = updated_form.get('12.排竞要求', '未设置')
                updated_form['12.排竞要求'] = ranking_value
                logger.info(f"✅ 更新 '12.排竞要求': {old_value} -> {ranking_value}")

                # 删除多余的 '排竞要求' 字段（如果存在）
                if '排竞要求' in updated_form:
                    del updated_form['排竞要求']
                    logger.info("✅ 删除多余的 '排竞要求' 字段")

            else:
                logger.warning("❌ 未能在baseTable中找到排竞要求")

            logger.info(f"最终form的12.排竞要求: {updated_form.get('12.排竞要求', '未找到')}")
            logger.info("=== 结束 update_form_ranking_competition_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新排竞要求时出错: {str(e)}", exc_info=True)
            return request_form

    def update_form_promotion_period_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取推广周期值并更新request.form的5.推广周期字段，删除多余的推广周期字段
        """
        try:
            logger.info("=== 开始执行 update_form_promotion_period_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取推广周期值 - 匹配格式如：11.10、11.15等日期格式
            period_match = re.search(r'5\.推广周期:\s*（\s*([^）]+)\s*）', base_table)

            if period_match:
                period_value = period_match.group(1).strip()  # 获取推广周期值
                logger.info(f"✅ 成功提取推广周期: {period_value}")

                # 更新 5.推广周期 字段
                old_value = updated_form.get('5.推广周期', '未设置')
                updated_form['5.推广周期'] = period_value
                logger.info(f"✅ 更新 '5.推广周期': {old_value} -> {period_value}")

                # 删除多余的 '推广周期' 字段（如果存在）
                if '推广周期' in updated_form:
                    del updated_form['推广周期']
                    logger.info("✅ 删除多余的 '推广周期' 字段")

            else:
                logger.warning("❌ 未能在baseTable中找到推广周期")

            logger.info(f"最终form的5.推广周期: {updated_form.get('5.推广周期', '未找到')}")
            logger.info("=== 结束 update_form_promotion_period_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新推广周期时出错: {str(e)}", exc_info=True)
            return request_form

    def update_form_creation_direction_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取创作方向值并更新request.form的11.创作方向字段，删除多余的创作方向字段
        """
        try:
            logger.info("=== 开始执行 update_form_creation_direction_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取创作方向值 - 匹配格式如：单品种草、测评等文本内容
            direction_match = re.search(r'11\.创作方向:\s*（\s*([^）]+)\s*）', base_table)

            if direction_match:
                direction_value = direction_match.group(1).strip()  # 获取创作方向值
                logger.info(f"✅ 成功提取创作方向: {direction_value}")

                # 更新 11.创作方向 字段
                old_value = updated_form.get('11.创作方向', '未设置')
                updated_form['11.创作方向'] = direction_value
                logger.info(f"✅ 更新 '11.创作方向': {old_value} -> {direction_value}")

                # 删除多余的 '创作方向' 字段（如果存在）
                if '创作方向' in updated_form:
                    del updated_form['创作方向']
                    logger.info("✅ 删除多余的 '创作方向' 字段")

            else:
                logger.warning("❌ 未能在baseTable中找到创作方向")

            logger.info(f"最终form的11.创作方向: {updated_form.get('11.创作方向', '未找到')}")
            logger.info("=== 结束 update_form_creation_direction_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新创作方向时出错: {str(e)}", exc_info=True)
            return request_form

    def update_form_data_guarantee_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取数据保证值并更新request.form的15.可保阅读数据和16.可保互动数据字段，删除多余的数据保证字段
        """
        try:
            logger.info("=== 开始执行 update_form_data_guarantee_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取可保阅读数据值 - 匹配格式如：视频保底1万播放，图文保底7000阅读等
            reading_match = re.search(r'15\.可保阅读数据:\s*（\s*([^）]+)\s*）', base_table)
            # 提取可保互动数据值 - 匹配格式如：点赞+评论≥400等
            interaction_match = re.search(r'16\.可保互动数据:\s*（\s*([^）]+)\s*）', base_table)

            if reading_match:
                reading_value = reading_match.group(1).strip()  # 获取可保阅读数据值
                logger.info(f"✅ 成功提取可保阅读数据: {reading_value}")

                # 更新 15.可保阅读数据 字段
                old_value = updated_form.get('15.可保阅读数据', '未设置')
                updated_form['15.可保阅读数据'] = reading_value
                logger.info(f"✅ 更新 '15.可保阅读数据': {old_value} -> {reading_value}")

            else:
                logger.warning("❌ 未能在baseTable中找到可保阅读数据")

            if interaction_match:
                interaction_value = interaction_match.group(1).strip()  # 获取可保互动数据值
                logger.info(f"✅ 成功提取可保互动数据: {interaction_value}")

                # 更新 16.可保互动数据 字段
                old_value = updated_form.get('16.可保互动数据', '未设置')
                updated_form['16.可保互动数据'] = interaction_value
                logger.info(f"✅ 更新 '16.可保互动数据': {old_value} -> {interaction_value}")

            else:
                logger.warning("❌ 未能在baseTable中找到可保互动数据")

            # 删除多余的数据保证相关字段（如果存在）
            if '可保阅读数据' in updated_form:
                del updated_form['可保阅读数据']
                logger.info("✅ 删除多余的 '可保阅读数据' 字段")

            if '可保互动数据' in updated_form:
                del updated_form['可保互动数据']
                logger.info("✅ 删除多余的 '可保互动数据' 字段")

            logger.info(f"最终form的15.可保阅读数据: {updated_form.get('15.可保阅读数据', '未找到')}")
            logger.info(f"最终form的16.可保互动数据: {updated_form.get('16.可保互动数据', '未找到')}")
            logger.info("=== 结束 update_form_data_guarantee_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新数据保证时出错: {str(e)}", exc_info=True)
            return request_form

    def update_form_tone_matching_from_base_table(self, request_form, base_table, user_input):
        """
        从baseTable中提取账号调性相关值并更新request.form的账号调性字段，删除多余的调性相关字段
        """
        try:
            logger.info("=== 开始执行 update_form_tone_matching_from_base_table ===")

            updated_form = request_form.copy()

            import re

            # 提取账号调性相关值 - 匹配账号调性描述
            # 注意：账号调性可能在多个字段中体现，这里匹配常见的调性相关字段
            tone_match = re.search(r'(账号调性|内容风格|账号定位):\s*（\s*([^）]+)\s*）', base_table)

            if tone_match:
                tone_value = tone_match.group(2).strip()  # 获取调性值
                field_name = tone_match.group(1)  # 获取字段名
                logger.info(f"✅ 成功提取{field_name}: {tone_value}")

                # 更新对应的账号调性字段
                if field_name == "账号调性":
                    old_value = updated_form.get('账号调性', '未设置')
                    updated_form['账号调性'] = tone_value
                    logger.info(f"✅ 更新 '账号调性': {old_value} -> {tone_value}")
                elif field_name == "内容风格":
                    old_value = updated_form.get('内容风格', '未设置')
                    updated_form['内容风格'] = tone_value
                    logger.info(f"✅ 更新 '内容风格': {old_value} -> {tone_value}")
                elif field_name == "账号定位":
                    old_value = updated_form.get('账号定位', '未设置')
                    updated_form['账号定位'] = tone_value
                    logger.info(f"✅ 更新 '账号定位': {old_value} -> {tone_value}")

            else:
                logger.warning("❌ 未能在baseTable中找到账号调性相关字段")

            # 删除多余的调性相关字段（如果存在重复）
            tone_fields_to_remove = ['调性', '账号风格', '内容调性']
            for field in tone_fields_to_remove:
                if field in updated_form:
                    del updated_form[field]
                    logger.info(f"✅ 删除多余的 '{field}' 字段")

            logger.info(
                f"最终form的账号调性相关字段: {[k for k in updated_form.keys() if '调性' in k or '风格' in k or '定位' in k]}")
            logger.info("=== 结束 update_form_tone_matching_from_base_table ===")
            return updated_form

        except Exception as e:
            logger.error(f"🚨 更新账号调性时出错: {str(e)}", exc_info=True)
            return request_form

    def extract_discount_values(self, diff_line_str):
        """
        从差异行中提取基础值和用户值
        格式示例: "折扣要求不一致，基础值：30%，用户值：52%"
        """
        import re
        # 使用正则表达式匹配百分比数字
        pattern = r'基础值：(\d+)%，用户值：(\d+)%'
        match = re.search(pattern, str(diff_line_str))
        if match:
            base_value = int(match.group(1))
            user_value = int(match.group(2))
            return base_value, user_value
        return None, None

    def check_and_filter_discount_diff(self, diff_info):
        """
        检查并过滤折扣要求差异
        如果用户折扣优于或等于基础折扣，则删除该差异项
        返回: (删除折扣行后的新列表, 删除后的第一行或空字符串)
        """
        if not diff_info:  # 确保diff_info不为空
            return [], ""  # 返回空列表和空字符串

        diff_line = diff_info[0]

        # 检查是否是折扣要求不一致的情况
        if "折扣要求不一致" in str(diff_line):
            base_discount, user_discount = self.extract_discount_values(diff_line)

            # 如果用户值大于等于基础值，则删除这一行
            if base_discount is not None and user_discount is not None:
                if user_discount >= base_discount:
                    # 创建新的列表，删除第一行
                    new_diff_info = diff_info[1:]  # 从第二行开始取，相当于删除第一行
                    # 如果还有剩余行，取第一行，否则为空字符串
                    new_diff_line = new_diff_info[0] if new_diff_info else ""
                    return new_diff_info, new_diff_line

        # 如果没有过滤，返回原样
        return diff_info, diff_line

    def clean_text_for_matching(self, text):
        """
        清理文本用于匹配：移除数字、标点、特殊字符等，只保留中英文和括号
        """
        logger.info(f"开始清理文本: '{text}'")
        if not text:
            logger.warning("输入文本为空，返回空字符串")
            return ""

        try:
            # 移除开头的数字和点（如"1."），移除特殊字符但保留中文、英文、数字、括号和空格
            cleaned = re.sub(r'^\d+\.', '', text)  # 移除开头的"1."等
            logger.debug(f"移除开头数字后: '{cleaned}'")

            cleaned = re.sub(r'[^\u4e00-\u9fa5a-zA-Z0-9\s\(\)（）]', '', cleaned)  # 只保留中英文、数字、空格和括号
            logger.debug(f"移除特殊字符后: '{cleaned}'")

            result = cleaned.strip()
            logger.info(f"文本清理完成，结果: '{result}'")
            return result
        except Exception as e:
            logger.error(f"清理文本时发生错误: {e}")
            return ""

    def is_text_similar(self, original, user_input):
        """
        判断两个文本是否大体相似
        """
        logger.info(f"开始文本相似度比较 - 原始文本: '{original}', 用户输入: '{user_input}'")

        if not original or not user_input:
            logger.warning(f"输入文本为空 - original: {original}, user_input: {user_input}")
            return False

        try:
            original_clean = self.clean_text_for_matching(original)
            user_clean = self.clean_text_for_matching(user_input)

            logger.debug(f"清理后文本 - 原始: '{original_clean}', 用户: '{user_clean}'")

            # 如果清理后完全相同，直接返回True
            if original_clean == user_clean:
                logger.info("清理后文本完全相同，返回True")
                return True

            # 如果清理后的文本长度差异太大，返回False
            len_diff = abs(len(original_clean) - len(user_clean))
            logger.debug(f"文本长度差异: {len_diff}")

            if len_diff > 3:
                logger.info(f"文本长度差异过大({len_diff})，返回False")
                return False

            # 计算相似度：共同字符的比例
            original_chars = set(original_clean)
            user_chars = set(user_clean)
            common_chars = original_chars & user_chars

            similarity = len(common_chars) / max(len(original_chars), len(user_chars), 1)

            logger.info(f"相似度计算完成 - 共同字符数: {len(common_chars)}, 相似度: {similarity:.2f}")

            result = similarity > 0.7
            logger.info(f"相似度判断结果: {result}")
            return result

        except Exception as e:
            logger.error(f"文本相似度比较时发生错误: {e}")
            return False

    #检查前四项一致性，给出不一致内容{error_info}的方法
    def check_form_consistency(self, base_table, user_input_form):
        """
        检查表单前四项的一致性
        返回: (是否一致, 错误信息, 详细对比信息)
        """
        logger.info("开始检查表单一致性")
        logger.debug(f"base_table类型: {type(base_table)}, 值: {base_table}")
        logger.debug(f"user_input_form类型: {type(user_input_form)}, 值: {user_input_form}")

        try:
            # 转换base_table为字典（如果是字符串）
            if isinstance(base_table, str):
                logger.info("base_table是字符串，尝试转换为字典")
                base_table_dict = self.convert_userInput_to_formDict(base_table)
                logger.debug(f"转换后的base_table: {base_table_dict}")
            else:
                base_table_dict = base_table

            # 转换user_input_form为字典（如果是字符串）
            if isinstance(user_input_form, str):
                logger.info("user_input_form是字符串，尝试转换为字典")
                user_input_form_dict = self.convert_userInput_to_formDict(user_input_form)
                logger.debug(f"转换后的user_input_form: {user_input_form_dict}")
            else:
                user_input_form_dict = user_input_form

            # 检查转换结果
            if "error" in base_table_dict:
                logger.error(f"base_table转换失败: {base_table_dict['error']}")
                return False, f"基础表单格式错误: {base_table_dict['error']}", ""

            if "error" in user_input_form_dict:
                logger.error(f"user_input_form转换失败: {user_input_form_dict['error']}")
                return False, f"用户表单格式错误: {user_input_form_dict['error']}", ""

            # 定义带数字前缀的字段名
            required_fields_with_prefix = ["1.达人昵称", "2.达人主页链接", "3.品牌/产品名称", "4.产品品类"]
            # 定义不带数字前缀的字段名（用于兼容）
            required_fields_without_prefix = ["达人昵称", "达人主页链接", "品牌/产品名称", "产品品类"]

            missing_fields = []
            detailed_comparison = []  # 存储详细的字段对比信息

            for i, field_with_prefix in enumerate(required_fields_with_prefix):
                field_without_prefix = required_fields_without_prefix[i]

                # 尝试用带数字前缀的字段名获取值
                base_value = base_table_dict.get(field_with_prefix, "")
                user_value = user_input_form_dict.get(field_with_prefix, "")

                # 如果值为空，尝试用不带数字前缀的字段名
                if not base_value:
                    base_value = base_table_dict.get(field_without_prefix, "")
                if not user_value:
                    user_value = user_input_form_dict.get(field_without_prefix, "")

                logger.debug(f"检查字段 '{field_with_prefix}' - base_value: '{base_value}', user_value: '{user_value}'")

                if not self.is_text_similar(base_value, user_value):
                    logger.warning(f"字段 '{field_with_prefix}' 不匹配")
                    missing_fields.append(field_without_prefix)
                    # 记录详细的对比信息
                    detailed_comparison.append({
                        'field': field_without_prefix,
                        'base_value': base_value,
                        'user_value': user_value
                    })
                else:
                    logger.info(f"字段 '{field_with_prefix}' 匹配成功")

            if missing_fields:
                error_msg = f"以下字段不匹配: {', '.join(missing_fields)}"
                logger.warning(f"表单一致性检查失败: {error_msg}")
                return False, error_msg, detailed_comparison

            logger.info("表单一致性检查通过")
            return True, "", []

        except Exception as e:
            logger.error(f"检查表单一致性时发生错误: {e}")
            return False, f"检查表单一致性时发生错误: {str(e)}", ""

    def get_previous_round_response(self, conversations, rounds_back=2):
        """
        从历史对话中获取前几轮的响应
        """
        logger.info(f"开始获取前{rounds_back}轮对话响应")
        logger.debug(f"对话历史数量: {len(conversations) if conversations else 0}")

        if not conversations:
            logger.warning("对话历史为空，返回None")
            return None

        try:
            # 从后往前搜索（最新的对话在最后）
            target_count = 0
            for i in range(len(conversations) - 1, -1, -1):
                conv = conversations[i]
                role = conv.get('role', '')
                content = conv.get('content', '')
                logger.debug(f"检查第{i}条消息 - 角色: {role}, 内容: '{content}'")

                if role == "assistant" and "宝子，这些东西请再核对一下呢" in content:
                    target_count += 1
                    logger.info(f"找到第{target_count}个目标响应在第{i}条消息")

                    if target_count == rounds_back:
                        logger.info(f"返回第{rounds_back}个目标响应")
                        return conv

            logger.info(f"共找到{target_count}个目标响应，但未找到第{rounds_back}个")
            return None

        except Exception as e:
            logger.error(f"获取历史对话响应时发生错误: {e}")
            return None

    def handle_form_validation(self, request, is_form, user_input, base_table):
        """
        处理表单验证的主要逻辑
        """
        logger.info(f"开始处理表单验证 - is_form: {is_form}, user_input: '{user_input}'")
        logger.debug(f"request类型: {type(request)}, base_table: {base_table}")

        try:
            if is_form == 1:
                logger.info("进入is_form=1的处理流程")
                return self._handle_form_validation_case_1(request, user_input, base_table)
            else:
                logger.info("进入is_form=0的处理流程")
                return self._handle_form_validation_case_0(request, user_input, base_table)
        except Exception as e:
            logger.error(f"处理表单验证时发生错误: {e}")
            raise

    def _handle_form_validation_case_1(self, request, user_input, base_table):
        """
        处理is_form=1的情况：直接比对前四项
        """
        logger.info("开始处理_case_1 - 直接比对前四项")
        logger.debug(f"用户输入: '{user_input}', base_table类型: {type(base_table)}, base_table: '{base_table}'")

        try:
            user_input_form = self.convert_userInput_to_formDict(user_input.replace("请填写表单\n：", ""))
            logger.debug(f"转换后的用户输入表单: {user_input_form}")

            # 检查前四项一致性 - 现在返回三个值
            is_consistent, error_info, detailed_comparison = self.check_form_consistency(base_table, user_input_form)
            logger.info(f"表单一致性检查结果: {is_consistent}, 错误信息: {error_info}")

            if is_consistent:
                logger.info("前四项全部匹配，更新form并继续后续流程")
                # 前四项全部匹配，更新form并继续后续流程
                for key in ["达人昵称", "达人主页链接", "品牌/产品名称", "产品品类"]:
                    if key in user_input_form:
                        request.form[key] = user_input_form[key]
                        logger.debug(f"更新字段 '{key}': {user_input_form[key]}")

                logger.info("返回None表示继续后续代码流程")
                return None
            else:
                logger.info("前四项不一致，返回相应的响应")
                # 前四项不一致，返回相应的响应
                return self._get_form_validation_response(request, error_info, request.conversations, user_input,
                                                          base_table, detailed_comparison)

        except Exception as e:
            logger.error(f"处理_case_1时发生错误: {e}")
            raise

    def _handle_form_validation_case_0(self, request, user_input, base_table):
        """
        处理is_form=0的情况：检查历史信息，用base_table中不匹配的字段去匹配user_input
        """
        logger.info("开始处理_case_0 - 检查历史信息并匹配user_input")
        logger.debug(f"用户输入: '{user_input}', base_table类型: {type(base_table)}, base_table: '{base_table}'")

        try:
            # 转换base_table为字典
            if isinstance(base_table, str):
                base_table_dict = self.convert_userInput_to_formDict(base_table)
            else:
                base_table_dict = base_table

            # 检查当前form与base_table的一致性，找出不匹配的字段
            is_consistent, error_info, detailed_comparison = self.check_form_consistency(base_table_dict, request.form)
            logger.info(f"初始表单一致性检查结果: {is_consistent}, 错误信息: {error_info}")

            # 如果不一致，尝试从user_input中匹配不匹配的字段
            if not is_consistent:
                logger.info("表单不一致，尝试从用户输入中匹配字段")
                updated_form = request.form.copy() if request.form else {}
                matched_fields = []

                # 定义需要检查的字段
                required_fields_with_prefix = ["1.达人昵称", "2.达人主页链接", "3.品牌/产品名称", "4.产品品类"]
                required_fields_without_prefix = ["达人昵称", "达人主页链接", "品牌/产品名称", "产品品类"]

                for i, field_with_prefix in enumerate(required_fields_with_prefix):
                    field_without_prefix = required_fields_without_prefix[i]

                    # 获取base_table中的正确值
                    base_value = base_table_dict.get(field_with_prefix, "")
                    if not base_value:
                        base_value = base_table_dict.get(field_without_prefix, "")

                    # 获取当前form中的值
                    current_value = updated_form.get(field_with_prefix, "")
                    if not current_value:
                        current_value = updated_form.get(field_without_prefix, "")

                    # 如果当前字段不匹配，检查user_input中是否提到了base_value
                    if base_value and not self.is_text_similar(base_value, current_value):
                        logger.debug(f"字段 '{field_without_prefix}' 不匹配，检查用户输入是否包含: '{base_value}'")

                        # 检查用户输入中是否提到了base_value的内容
                        if self.is_text_in_user_input(base_value, user_input):
                            logger.info(f"用户在输入中提到了字段 '{field_without_prefix}' 的正确内容")
                            # 更新form
                            if field_with_prefix in base_table_dict:
                                updated_form[field_with_prefix] = base_table_dict[field_with_prefix]
                            elif field_without_prefix in base_table_dict:
                                updated_form[field_without_prefix] = base_table_dict[field_without_prefix]
                            matched_fields.append(field_without_prefix)

                # 如果有字段被匹配并更新，重新检查一致性
                if matched_fields:
                    logger.info(f"通过用户输入匹配了以下字段: {matched_fields}")
                    request.form = updated_form
                    is_consistent_after_update, new_error_info, new_detailed_comparison = self.check_form_consistency(
                        base_table_dict, request.form)
                    logger.info(f"更新后表单一致性检查结果: {is_consistent_after_update}, 错误信息: {new_error_info}")

                    if is_consistent_after_update:
                        logger.info("所有字段已匹配，返回None继续流程")
                        return None  # 这里直接返回，不再执行后面的历史对话检查
                    else:
                        error_info = new_error_info
                        detailed_comparison = new_detailed_comparison
                        # 如果更新后仍然不一致，继续执行下面的历史对话检查
                else:
                    # 如果没有匹配到任何字段，继续执行下面的历史对话检查
                    logger.info("未匹配到任何字段，继续检查历史对话")
            else:
                # 如果一开始就一致，直接返回None继续流程
                logger.info("表单一开始就一致，返回None继续流程")
                return None

            # 只有在前四项仍然不一致的情况下，才执行历史对话检查
            logger.info("前四项仍然不一致，开始检查历史对话")

            # 检查历史对话
            previous_response = self.get_previous_round_response(request.conversations, 2)
            logger.debug(f"前2轮响应: {previous_response}")

            if previous_response and "宝子，这些东西请再核对一下呢" in previous_response.get('content', ''):
                logger.info("检测到第二轮检查，仍然不匹配，返回拒绝响应")
                return SecondBargainingResponse(
                    form=request.form,
                    agent_response="好的宝子，待项目确认后再与您继续沟通哈~",
                    cooperation_status="已拒品",
                    is_submit=1,
                    category="选错达人，博主基本信息不一致",
                    subcategory="博主信息不一致"
                )
            else:
                logger.info("检查第一轮响应")
                previous_response_first = self.get_previous_round_response(request.conversations, 1)
                logger.debug(f"前1轮响应: {previous_response_first}")

                if previous_response_first and "宝子，这些东西请再核对一下呢" in previous_response_first.get('content',
                                                                                                            ''):
                    logger.info("检测到第一轮后的再次检查，仍然不匹配")
                    return self._get_form_validation_response(request, error_info, request.conversations, user_input,
                                                              base_table, detailed_comparison)
                else:
                    logger.info("第一次发现不匹配")
                    return self._get_form_validation_response(request, error_info, request.conversations, user_input,
                                                              base_table, detailed_comparison)

        except Exception as e:
            logger.error(f"处理_case_0时发生错误: {e}")
            raise

    def is_text_in_user_input(self, base_value, user_input):
        """
        检查base_value中的关键信息是否出现在user_input中
        """
        if not base_value or not user_input:
            return False

        # 清理base_value，提取关键信息
        cleaned_base = self.clean_text_for_matching(base_value)
        cleaned_user = self.clean_text_for_matching(user_input)

        # 如果base_value很短，直接检查是否包含
        if len(cleaned_base) <= 6:
            return cleaned_base in cleaned_user

        # 对于较长的文本，提取关键词进行检查
        keywords = self.extract_keywords(cleaned_base)
        logger.debug(f"从base_value '{cleaned_base}' 提取关键词: {keywords}")

        matched_keywords = 0
        for keyword in keywords:
            if keyword and len(keyword) > 1 and keyword in cleaned_user:
                matched_keywords += 1
                logger.debug(f"匹配到关键词: '{keyword}'")

        # 如果匹配到足够多的关键词，认为用户提到了相关内容
        return matched_keywords >= max(1, len(keywords) // 2)

    def extract_keywords(self, text):
        """
        从文本中提取关键词（简单实现）
        """
        if not text:
            return []

        # 移除常见停用词，提取有意义的词汇
        stop_words = {"的", "是", "在", "和", "与", "及", "这个", "那个", "一些"}

        # 按空格和标点分割
        words = re.findall(r'[\u4e00-\u9fa5a-zA-Z0-9]{2,}', text)

        # 过滤停用词和过短的词
        keywords = [word for word in words if word not in stop_words and len(word) >= 2]

        return keywords

    def _get_form_validation_response(self, request, error_info, conversations, user_input, base_table,
                                      detailed_comparison):
        """
        根据对话轮次返回相应的表单验证响应
        """
        logger.info(f"开始生成表单验证响应 - 错误信息: {error_info}")
        logger.debug(f"用户输入: '{user_input}', base_table: {base_table}")

        try:
            # 生成详细的错误信息
            whole_error = self._generate_detailed_error_message(detailed_comparison)
            logger.info(f"生成的详细错误信息: {whole_error}")

            # 检查历史对话
            previous_response = self.get_previous_round_response(conversations, 2)
            logger.debug(f"前2轮响应: {previous_response}")

            if previous_response and "宝子，这些东西请再核对一下呢" in previous_response.get('content', ''):
                logger.info("检测到第二轮检查，返回拒绝响应")
                # 这是第二轮检查，仍然不匹配
                return SecondBargainingResponse(
                    form=request.form,
                    agent_response="好的宝子，待项目确认后再与您继续沟通哈~",
                    cooperation_status="已拒品",
                    is_submit=1,
                    category="选错达人，博主基本信息不一致",
                    subcategory="博主信息不一致"
                )
            else:
                logger.info("检查第一轮响应")
                # 第一轮检查不匹配
                previous_response_first = self.get_previous_round_response(conversations, 1)
                logger.debug(f"前1轮响应: {previous_response_first}")

                if previous_response_first and "宝子，这些东西请再核对一下呢" in previous_response_first.get('content',
                                                                                                            ''):
                    logger.info("检测到第一轮后的再次检查，返回提醒响应")
                    # 这是第一轮后的再次检查，仍然不匹配
                    return SecondBargainingResponse(
                        form=request.form,
                        agent_response=f"宝子现在还是有一些字段是不匹配的呢，{whole_error}" + splitter,
                        cooperation_status="沟通中",
                        is_submit=1,
                        category="",
                        subcategory="博主权益落实中"
                    )
                else:
                    logger.info("第一次发现不匹配，返回初始提醒响应")
                    # 第一次发现不匹配
                    return SecondBargainingResponse(
                        form=request.form,
                        agent_response=f"宝子，这些东西请再核对一下呢？博主信息一定要匹配捏，{whole_error}" + splitter,
                        cooperation_status="沟通中",
                        is_submit=1,
                        category="",
                        subcategory="博主权益落实中"
                    )
        except Exception as e:
            logger.error(f"生成表单验证响应时发生错误: {e}")
            raise

    def _generate_detailed_error_message(self, detailed_comparison):
        """
        生成详细的错误信息
        格式：博主的正确信息是 达人昵称：米兜妈Dumia 产品品类:奶粉。宝子您填的是达人昵称：爱吃红烧肉 产品品类:美食预制菜。看看您是不是手滑写错了呢？
        """
        if not detailed_comparison:
            return "请核对一下表单信息呢"

        base_info_parts = []
        user_info_parts = []

        for comparison in detailed_comparison:
            field = comparison['field']
            base_value = comparison['base_value'] or "未填写"
            user_value = comparison['user_value'] or "未填写"

            base_info_parts.append(f"{field}：{base_value}")
            user_info_parts.append(f"{field}：{user_value}")

        base_info = " ".join(base_info_parts)
        user_info = " ".join(user_info_parts)

        return f"博主的正确信息是 {base_info}。宝子您填的是{user_info}。看看您是不是手滑写错了呢？"

    def convert_userInput_to_formDict(self, text: str) -> dict:
        """
        转换用户给的表单字符串成为dict
        """
        logger.info(f"开始转换用户输入为表单字典: '{text}'")

        try:
            # 如果输入已经是字典，直接返回
            if isinstance(text, dict):
                logger.info("输入已经是字典类型，直接返回")
                return text

            # 如果是空字符串
            if not text or not text.strip():
                logger.warning("输入文本为空，返回空字典")
                return {}

            lines = text.split('\n')
            logger.debug(f"分割后的行数: {len(lines)}")

            result_dict = {}

            for i, line in enumerate(lines):
                logger.debug(f"处理第{i + 1}行: '{line}'")
                line = line.strip()
                if not line:
                    continue

                # 处理多种分隔符
                line = line.replace("：", ":")  # 中文冒号转英文冒号

                if ':' in line:
                    field_parts = line.split(':', 1)
                    field_name = field_parts[0].strip()
                    field_value = field_parts[1].strip()

                    # 移除字段名中的示例文本（如"（例:..."）
                    if '（例:' in field_name:
                        field_name = field_name.split('（例:')[0].strip()

                    result_dict[field_name] = field_value
                    logger.debug(f"提取字段: '{field_name}' = '{field_value}'")
                else:
                    logger.debug(f"跳过不含冒号的行: '{line}'")

            logger.info(f"表单转换完成，结果: {result_dict}")
            return result_dict

        except Exception as e:
            logger.error(f"转换用户输入为表单字典时发生错误: {e}")
            return {"error": f"处理表单失败: {str(e)}"}

    #推广周期获取用户时间与博主时间方法
    def extract_dates(self, diff_line):
        # 匹配各种日期格式：
        # - 数字月数字日（10月2日、10月02日）
        # - 数字.数字（11.2、10.02）
        # - 中文数字月数字日（十月二日、十月02日）
        # - 混合格式（10月二日、十月2日）
        # - 时间段格式（9.01-10.31、10月1日-10月31日）

        # 单个日期模式
        single_date_pattern = r'(\d{1,2}月\d{1,2}日|十[一二]?月[一二三四五六七八九十\d]{1,3}日|\d{1,2}\.\d{1,2})'

        # 时间段模式（开始日期-结束日期）
        date_range_pattern = r'(' + single_date_pattern + r'[-~至]' + single_date_pattern + r')'

        def extract_final_date(date_str):
            """从日期字符串中提取最终的日期（对于时间段取最后一个）"""
            if date_str == "未知":
                return "未知"

            # 如果是时间段格式（包含-、~、至等连接符）
            if re.search(r'[-~至]', date_str):
                # 分割时间段，取最后一个部分
                parts = re.split(r'[-~至]', date_str)
                if parts:
                    return parts[-1].strip()
            return date_str

        # 提取用户值日期
        user_date_match = re.search(r'用户值[：:]?' + date_range_pattern, diff_line)
        if not user_date_match:
            user_date_match = re.search(r'用户值[：:]?' + single_date_pattern, diff_line)

        user_date = user_date_match.group(1) if user_date_match else "未知"
        user_date = extract_final_date(user_date)

        # 提取基础值日期
        our_date_match = re.search(r'基础值[：:]?' + date_range_pattern, diff_line)
        if not our_date_match:
            our_date_match = re.search(r'基础值[：:]?' + single_date_pattern, diff_line)

        our_date = our_date_match.group(1) if our_date_match else "未知"
        our_date = extract_final_date(our_date)

        # 如果基础值没找到，尝试其他常见表述
        if our_date == "未知":
            alternative_patterns = [
                r'档期要求[：:]?' + date_range_pattern,
                r'要求[：:]?' + date_range_pattern,
                r'最快档期[：:]?' + date_range_pattern,
                r'档期要求[：:]?' + single_date_pattern,
                r'要求[：:]?' + single_date_pattern,
                r'最快档期[：:]?' + single_date_pattern,
                date_range_pattern,  # 直接匹配时间段
                single_date_pattern  # 直接匹配日期
            ]

            for pattern in alternative_patterns:
                match = re.search(pattern, diff_line)
                if match:
                    our_date = match.group(1)
                    our_date = extract_final_date(our_date)
                    break

        logger.info(f"用户日期: {user_date}, 基础日期: {our_date}")
        return user_date, our_date

    def update_promotion_period(self, diff_info: List[str], user_input: str) -> Tuple[List[str], str]:
        """
        更新推广周期，如果user_input中的日期更早则替换
        """
        logger.info(f"【推广周期】进入方法，原始diff_line: {diff_info[0] if diff_info else '空'}")

        if not diff_info:
            logger.info("【推广周期】diff_info为空，直接返回")
            return diff_info, ""

        diff_line = diff_info[0]

        # 检查是否是推广周期格式
        condition1 = "推广周期不一致" not in diff_line
        condition2 = "基础值：" not in diff_line
        condition3 = "用户值：" not in diff_line
        logger.info(
            f"【推广周期】检查条件: 推广周期不一致不在={condition1}, 基础值不在={condition2}, 用户值不在={condition3}")

        if condition1 or condition2 or condition3:
            logger.info(f"【推广周期】不符合处理条件，直接返回。当前diff_line: {diff_line}")
            # 为了安全，返回副本而不是原对象
            return diff_info.copy(), diff_line

        logger.info("【推广周期】符合处理条件，开始处理...")

        try:
            # 提取原始日期
            user_date, our_date = self.extract_dates(diff_line)
            logger.info(f"【推广周期】提取的日期: user_date={user_date}, our_date={our_date}")

            if user_date == "未知":
                logger.info("【推广周期】日期未知，直接返回")
                return diff_info.copy(), diff_line

            # 从user_input中提取日期
            input_dates = re.findall(r'(\d{1,2}\.\d{1,2}|\d{1,2}月\d{1,2}日)', user_input)
            logger.info(f"【推广周期】从用户输入提取的日期: {input_dates}")

            if not input_dates:
                logger.info("【推广周期】未提取到日期，直接返回")
                return diff_info.copy(), diff_line

            # 获取要比较的日期（如果是时间段取最后一个）
            original_compare_date = user_date.split('-')[-1] if '-' in user_date else user_date
            input_compare_date = input_dates[0].split('-')[-1] if '-' in input_dates[0] else input_dates[0]
            logger.info(f"【推广周期】比较日期: 原始={original_compare_date}, 输入={input_compare_date}")

            # 比较日期，如果input更早就替换
            if self._is_date_earlier(input_compare_date, original_compare_date):
                new_diff_line = diff_line.replace(f"用户值：{user_date}", f"用户值：{input_compare_date}")
                logger.info(f"【推广周期】需要更新，新diff_line: {new_diff_line}")
                # 创建新的列表避免修改原数据
                new_diff_info = diff_info.copy()
                new_diff_info[0] = new_diff_line
                return new_diff_info, new_diff_line
            else:
                logger.info("【推广周期】不需要更新日期")

        except Exception as e:
            logger.error(f"【推广周期】更新推广周期失败: {e}")
            import traceback
            logger.error(traceback.format_exc())

        logger.info(f"【推广周期】最终返回，diff_line: {diff_line}")
        return diff_info.copy(), diff_line

    #更新推广周diff_line期的方法
    def _is_date_earlier(self, date1: str, date2: str) -> bool:
        """
        比较两个日期哪个更早

        :param date1: 日期1
        :param date2: 日期2
        :return: date1是否比date2早
        """
        try:
            # 统一格式为数字比较
            def parse_date(date_str):
                if '月' in date_str:
                    month, day = date_str.replace('日', '').split('月')
                    return int(month), int(day)
                else:
                    month, day = date_str.split('.')
                    return int(month), int(day)

            month1, day1 = parse_date(date1)
            month2, day2 = parse_date(date2)

            return (month1 < month2) or (month1 == month2 and day1 < day2)

        except Exception as e:
            logger.warning(f"日期比较失败: {date1} vs {date2}, 错误: {e}")
            return False

    def extract_discounts(self, diff_line: str) -> Tuple[str, str]:
        """
        增强版折扣提取，支持多种格式
        """
        try:
            self.logger.info(f"🎯【折扣提取】开始提取折扣信息，输入文本: '{diff_line}'")

            # 用户值折扣提取 - 调整模式顺序，优先匹配简单格式
            user_discount_patterns = [
                r'用户值\s*(\d+)',  # 用户值22（优先匹配简单格式）
                r'用户值[：:]\s*(\d+)',  # 用户值：22
                r'用户值[：:].*?(\d+)%?',  # 用户值：不低于22%
                r'用户折扣[：:]\s*(\d+)%?',  # 用户折扣：22%
                r'用户要求[：:].*?(\d+)%'  # 用户要求：22%
            ]

            user_discount = "未知"
            self.logger.info(f"🔍【折扣提取】开始用户值模式匹配，共有{len(user_discount_patterns)}个模式")

            for i, pattern in enumerate(user_discount_patterns):
                match = re.search(pattern, diff_line)
                self.logger.info(f"🔍【折扣提取】用户值模式{i + 1}: '{pattern}' -> 匹配结果: {match}")
                if match:
                    user_discount = match.group(1)
                    self.logger.info(f"✅【折扣提取】模式{i + 1}匹配成功！提取到用户折扣值: {user_discount}")
                    break

            # 基础值折扣提取 - 调整模式顺序，优先匹配简单格式
            base_discount_patterns = [
                r'基础值\s*(\d+)',  # 基础值30（优先匹配简单格式）
                r'基础值[：:]\s*(\d+)',  # 基础值：30
                r'基础值[：:].*?(\d+)%?',  # 基础值：不低于30%
                r'基础折扣[：:]\s*(\d+)%?',  # 基础折扣：30%
                r'要求[：:].*?(\d+)%?',  # 要求：30%
                r'折扣要求[：:].*?(\d+)%?',  # 折扣要求：30%
                r'不低于\s*(\d+)%?',  # 不低于30%
                r'最低\s*(\d+)%?'  # 最低30%
            ]

            base_discount = user_discount  # 默认使用用户折扣
            self.logger.info(f"🔍【折扣提取】开始基础值模式匹配，共有{len(base_discount_patterns)}个模式")

            for i, pattern in enumerate(base_discount_patterns):
                match = re.search(pattern, diff_line)
                self.logger.info(f"🔍【折扣提取】基础值模式{i + 1}: '{pattern}' -> 匹配结果: {match}")
                if match:
                    base_discount = match.group(1)
                    self.logger.info(f"✅【折扣提取】模式{i + 1}匹配成功！提取到基础折扣值: {base_discount}")
                    break

            # 如果基础值还是用户值，尝试从其他位置提取
            if base_discount == user_discount and user_discount != "未知":
                self.logger.info("🔄【折扣提取】基础值与用户值相同，尝试其他提取方式")
                # 尝试从差异描述的其他部分提取基础值
                other_base_patterns = [
                    r'基础值.*?(\d+)',
                    r'要求.*?(\d+)',
                    r'不低于.*?(\d+)'
                ]
                for i, pattern in enumerate(other_base_patterns):
                    matches = re.findall(pattern, diff_line)
                    self.logger.info(f"🔄【折扣提取】其他模式{i + 1}: '{pattern}' -> 找到匹配: {matches}")
                    if len(matches) > 1:  # 有多个数字，取第一个作为基础值
                        base_discount = matches[0]
                        self.logger.info(f"✅【折扣提取】从多个值中提取基础折扣: {base_discount}")
                        break

            # 最后兜底策略：提取所有数字
            if base_discount == "未知" or user_discount == "未知":
                self.logger.info("🔄【折扣提取】开始兜底策略：提取所有数字")
                all_numbers = re.findall(r'\d+', diff_line)
                self.logger.info(f"🔄【折扣提取】找到所有数字: {all_numbers}")
                if len(all_numbers) >= 2:
                    if base_discount == "未知":
                        base_discount = all_numbers[0]
                        self.logger.info(f"🔄【折扣提取】兜底提取基础折扣: {base_discount}")
                    if user_discount == "未知":
                        user_discount = all_numbers[1]
                        self.logger.info(f"🔄【折扣提取】兜底提取用户折扣: {user_discount}")
                elif len(all_numbers) == 1:
                    if base_discount == "未知":
                        base_discount = all_numbers[0]
                        self.logger.info(f"🔄【折扣提取】兜底提取唯一折扣值: {base_discount}")
                    if user_discount == "未知":
                        user_discount = all_numbers[0]
                        self.logger.info(f"🔄【折扣提取】使用唯一值作为用户折扣: {user_discount}")

            self.logger.info(f"📊【折扣提取】最终提取结果 - 用户值: {user_discount}, 基础值: {base_discount}")
            return user_discount, base_discount

        except Exception as e:
            logger.error(f"🚨【折扣提取】提取折扣值时出错: {str(e)}")
            import traceback
            logger.error(f"🚨【折扣提取】错误详情: {traceback.format_exc()}")
            return "未知", "未知"

    #更新每轮折扣要求的方法：
    def update_discount_requirement(self, request, user_input: str):
        """
        更新折扣要求，如果user_input中的折扣更高则替换
        """
        logger.info(f"【折扣要求】进入方法，原始diff_line: {request.diff_info[0] if request.diff_info else '空'}")

        if not request.diff_info:
            return request

        diff_line = request.diff_info[0]

        # 检查是否是折扣要求格式
        condition1 = "折扣要求不一致" not in diff_line
        condition2 = "基础值：" not in diff_line
        condition3 = "用户值：" not in diff_line
        logger.info(
            f"【折扣要求】检查条件: 折扣要求不一致不在={condition1}, 基础值不在={condition2}, 用户值不在={condition3}")

        if condition1 or condition2 or condition3:
            logger.info(f"【折扣要求】不符合处理条件，直接返回")
            return request

        try:
            # 提取原始折扣值
            user_discount, our_discount = self.extract_discounts(diff_line)
            logger.info(f"【折扣要求】提取的折扣: user_discount={user_discount}, our_discount={our_discount}")

            if user_discount == "未知":
                return request

            # 从user_input中提取折扣数字
            discount_numbers = re.findall(r'(\d+(?:\.\d+)?)%?', user_input)
            logger.info(f"【折扣要求】从用户输入提取的数字: {discount_numbers}")

            if not discount_numbers:
                return request

            # 获取用户输入的最大折扣值
            input_discount = max(float(num) for num in discount_numbers)
            logger.info(f"【折扣要求】用户输入的最大折扣: {input_discount}")

            # 比较折扣值，如果input更高就替换
            current_user_discount = float(user_discount.rstrip('%'))
            logger.info(f"【折扣要求】比较: 当前用户值={current_user_discount}, 输入值={input_discount}")

            if input_discount > current_user_discount:
                # 更新diff_line和diff_info
                new_user_discount = f"{int(input_discount)}"
                new_diff_line = diff_line.replace(f"用户值：{user_discount}", f"用户值：{new_user_discount}")
                logger.info(f"【折扣要求】需要更新，新diff_line: {new_diff_line}")

                # 创建新的diff_info列表，避免修改原对象
                new_diff_info = request.diff_info.copy()
                new_diff_info[0] = new_diff_line

                # 创建新的request对象或更新现有对象
                request.diff_info = new_diff_info

                # 更新request.form中的折扣要求
                if "10.折扣要求" in request.form:
                    request.form["10.折扣要求"] = new_user_discount
                elif "折扣要求" in request.form:
                    request.form["折扣要求"] = new_user_discount

                logger.info(f"【折扣要求】更新完成")
                return request
            else:
                logger.info(f"【折扣要求】不需要更新折扣")

        except Exception as e:
            logger.error(f"【折扣要求】更新折扣要求失败: {e}")
            import traceback
            logger.error(traceback.format_exc())

        return request



